const app = getApp();
const { post, get } = require('../../../utils/request');
const auth = require('../../../utils/auth');

// 格式化价格，添加¥符号和保留2位小数
const formatPrice = (price) => {
  if (price == null || isNaN(price)) return '¥0.00';
  return '¥' + parseFloat(price).toFixed(2);
};

Page({
  data: {
    // 页签相关
    activeTab: 0, // 当前激活的页签，0: 可申请的服务，1: 我提供的服务
    tabs: ['可申请的服务', '我提供的服务'],

    // 服务列表相关
    serviceList: [], // 可申请的服务列表
    myServiceList: [], // 我提供的服务列表

    // 加载状态
    loading: true,
    categoryLoading: false,
    serviceLoading: false,
    myServiceLoading: false,

    // 分类相关
    categories: [],
    selectedCategoryId: 0,

    // 弹窗相关
    showConfirmModal: false,
    selectedService: null,

    // 分页相关
    currentPage: 1,
    pageSize: 10,
    hasMore: true,
    lastRefreshTime: ''
  },

  onLoad(options) {
    this.checkPermission();
    this.loadCategories();

    // 如果有传入tab参数，切换到对应页签
    if (options && options.tab) {
      const tabIndex = parseInt(options.tab);
      if (tabIndex === 0 || tabIndex === 1) {
        this.setData({
          activeTab: tabIndex
        });
      }
    }

    // 设置最后刷新时间
    this.setData({
      lastRefreshTime: this.formatRefreshTime(new Date())
    });

    // 根据当前页签加载对应数据
    this.loadDataByActiveTab();
  },

  onShow() {
    // 每次页面显示时刷新数据
    this.loadDataByActiveTab();
  },

  // 格式化刷新时间
  formatRefreshTime(date) {
    const hour = date.getHours().toString().padStart(2, '0');
    const minute = date.getMinutes().toString().padStart(2, '0');
    return `${hour}:${minute}`;
  },

  // 检查权限
  checkPermission() {
    // 只允许服务人员访问
    if (!auth.isProvider()) {
      wx.showToast({
        title: '您不是服务人员，无法访问此页面',
        icon: 'none'
      });

      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
    }
  },

  // 加载服务分类 - 使用listCategoryVOByPage接口
  loadCategories() {
    this.setData({
      loading: true,
      categoryLoading: true
    });

    post('/api/category/list/page/vo', {
      current: 1,
      pageSize: 20
    })
      .then(res => {
        if (res.code === 0 && res.data) {
          // 处理分类数据
          const categoriesData = res.data.records || [];
          // 添加"全部"分类作为第一个选项
          const categories = [{ id: 0, name: '全部' }].concat(categoriesData.map(item => ({
            id: item.id,
            name: item.name,
            image: item.image || '/assets/images/default.png'
          })));

          this.setData({
            categories: categories,
            categoryLoading: false,
            selectedCategoryId: 0
          });

          // 加载所有服务
          this.loadServicesByCategory(0);
        } else {
          wx.showToast({
            title: res.message || '获取分类失败',
            icon: 'none'
          });
          this.setData({
            categories: [{ id: 0, name: '全部' }],
            categoryLoading: false,
            loading: false
          });
        }
      })
      .catch(err => {
        console.error('获取服务分类失败:', err);
        wx.showToast({
          title: '网络错误，请稍后重试',
          icon: 'none'
        });
        this.setData({
          categories: [{ id: 0, name: '全部' }],
          categoryLoading: false,
          loading: false
        });
      });
  },

  // 根据当前激活的页签加载数据
  loadDataByActiveTab() {
    try {
      // 先设置加载状态
      this.setData({
        loading: true
      });

      if (this.data.activeTab === 0) {
        // 加载可申请的服务列表
        this.loadServicesByCategory(this.data.selectedCategoryId, true);
      } else {
        // 加载我提供的服务列表
        this.loadMyServices();
      }
    } catch (error) {
      console.error('加载数据失败:', error);
      wx.showToast({
        title: '加载数据失败，请稍后重试',
        icon: 'none'
      });
      this.setData({
        loading: false,
        serviceLoading: false,
        myServiceLoading: false
      });
    }
  },

  // 切换页签
  switchTab(e) {
    const tabIndex = e.currentTarget.dataset.index;
    if (tabIndex === this.data.activeTab) return;

    this.setData({
      activeTab: tabIndex,
      loading: true // 设置加载状态，避免页面闪烁
    });

    // 切换页签后加载对应数据
    this.loadDataByActiveTab();
  },

  // 加载我提供的服务列表
  loadMyServices(resetPage = true) {
    this.setData({
      myServiceLoading: true,
      loading: true
    });

    // 获取当前服务人员ID
    const userInfo = auth.getUserInfo();
    const providerId = userInfo.id;

    // 如果是重置页面，重置分页参数
    if (resetPage) {
      this.setData({
        currentPage: 1,
        myServiceList: [],
        hasMore: true
      });
    }

    // 构建请求参数
    const params = {
      current: this.data.currentPage,
      size: this.data.pageSize,
      providerId: providerId
    };

    get('/api/provider-service/approved/byId', params)
      .then(res => {

        if (res.code === 0 && res.data) {
          const newServices = res.data.records || [];

          // 更新服务列表，如果是重置页面则替换，否则追加
          const updatedServices = resetPage
            ? newServices
            : [...this.data.myServiceList, ...newServices];

          this.setData({
            myServiceList: updatedServices,
            hasMore: newServices.length >= this.data.pageSize,
            myServiceLoading: false,
            loading: false
          });
        } else {
          console.error('获取我的服务列表失败:', res.message);
          wx.showToast({
            title: res.message || '获取我的服务列表失败',
            icon: 'none'
          });
          this.setData({
            myServiceList: resetPage ? [] : this.data.myServiceList, // 确保myServiceList始终有值
            myServiceLoading: false,
            loading: false,
            hasMore: false
          });
        }
      })
      .catch(err => {
        console.error('获取我的服务列表失败:', err);
        wx.showToast({
          title: '网络错误，请稍后重试',
          icon: 'none'
        });
        this.setData({
          myServiceList: resetPage ? [] : this.data.myServiceList, // 确保myServiceList始终有值
          myServiceLoading: false,
          loading: false,
          hasMore: false
        });
      });
  },

  // 加载更多我提供的服务
  loadMoreMyServices() {
    if (this.data.hasMore && !this.data.myServiceLoading) {
      this.setData({
        currentPage: this.data.currentPage + 1,
        myServiceLoading: true
      });
      this.loadMyServices(false);
    }
  },

  // 加载可申请的服务列表 - 使用listServicesVOByPage接口
  loadServicesByCategory(categoryId, resetPage = true) {
    // 设置选中的分类ID
    this.setData({
      selectedCategoryId: categoryId,
      loading: true,
      serviceLoading: true
    });

    // 如果是重置页面，重置列表和分页数据
    if (resetPage) {
      this.setData({
        serviceList: [], // 清空现有数据
        hasMore: true,
        currentPage: 1
      });
    }

    // 构建请求参数
    const params = {
      current: this.data.currentPage,
      size: this.data.pageSize,
    };

    // 只有当categoryId不为0时，才添加到请求参数中
    if (categoryId !== 0) {
      params.categoryId = categoryId;
    }

    get('/api/services/list/category', params)
      .then(res => {

        if (res.code === 0 && res.data) {
          const services = res.data || [];

          // 处理服务列表数据
          const formattedServices = services.map(service => ({
            ...service,
            priceText: formatPrice(service.price),
            unit: service.unit || '次' // 添加默认单位
          }));

          // 更新服务列表，如果是加载更多则追加，否则替换
          const updatedServiceList = resetPage
            ? formattedServices
            : [...this.data.serviceList, ...formattedServices];


          this.setData({
            serviceList: updatedServiceList,
            loading: false,
            serviceLoading: false,
            hasMore: formattedServices.length >= this.data.pageSize
          }, () => {
          });
        } else {
          wx.showToast({
            title: res.message || '获取服务失败',
            icon: 'none'
          });
          this.setData({
            loading: false,
            serviceLoading: false
          });
        }
      })
      .catch(err => {
        console.error('获取服务列表失败:', err);
        wx.showToast({
          title: '网络错误，请稍后重试',
          icon: 'none'
        });
        this.setData({
          loading: false,
          serviceLoading: false
        });
      });
  },

  // 加载更多服务
  loadMoreServices() {
    if (this.data.hasMore && !this.data.serviceLoading) {
      this.setData({
        currentPage: this.data.currentPage + 1,
        serviceLoading: true
      });
      this.loadServicesByCategory(this.data.selectedCategoryId, false);
    }
  },

  // 切换分类
  handleCategoryChange(e) {
    const categoryId = e.currentTarget.dataset.id;

    if (categoryId === this.data.selectedCategoryId) {
      return; // 避免重复加载
    }

    // 先设置loading状态，避免页面闪烁
    this.setData({
      loading: true,
      serviceLoading: true,
      // 确保activeTab保持在0（可申请的服务）
      activeTab: 0
    });

    // 加载选中分类的服务
    this.loadServicesByCategory(categoryId, true);
  },

  // 显示申请确认弹窗
  showApplyConfirm(e) {
    const serviceId = e.currentTarget.dataset.id;
    const service = this.data.serviceList.find(item => item.id === serviceId);

    if (service) {
      this.setData({
        selectedService: service,
        showConfirmModal: true
      });
    }
  },

  // 关闭确认弹窗
  closeConfirmModal() {
    this.setData({
      showConfirmModal: false
    });
  },

  // 提交服务申请
  submitServiceApplication() {
    if (!this.data.selectedService) {
      return;
    }

    const serviceId = this.data.selectedService.id;

    // 构建请求数据
    const data = {
      serviceId: serviceId
    };

    post('/api/provider-service/add', data)
      .then(res => {
        if (res.code === 0) {
          wx.showToast({
            title: '申请成功',
            icon: 'success'
          });

          // 关闭弹窗
          this.setData({
            showConfirmModal: false
          });
        } else {
          wx.showToast({
            title: res.message || '申请失败',
            icon: 'none'
          });
        }
      })
      .catch(err => {
        console.error('申请服务失败:', err);
        wx.showToast({
          title: '网络错误，请稍后重试',
          icon: 'none'
        });
      });
  },

  // 下拉刷新
  onPullDownRefresh() {
    this.setData({
      lastRefreshTime: this.formatRefreshTime(new Date())
    });

    // 根据当前页签刷新数据
    if (this.data.activeTab === 0) {
      this.loadServicesByCategory(this.data.selectedCategoryId, true);
    } else {
      this.loadMyServices();
    }

    wx.stopPullDownRefresh();
  },

  // 上拉加载更多
  onReachBottom() {
    // 根据当前页签加载更多
    if (this.data.activeTab === 0) {
      // 可申请的服务页签
      this.loadMoreServices();
    } else if (this.data.activeTab === 1) {
      // 我提供的服务页签
      this.loadMoreMyServices();
    }
  }
})